<?php

/**
 * 通用ＲＰＣ方法
 * 注意：调用此类中的方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
 *
 * @author birdy <freebirdy@foxmail.com>
 * @link http://www.aiyuangong.com
 */

namespace app\common\rpc;

/**
 * Description of Common
 *
 * @author ayg
 */
class Common extends Rpc
{
    /**
     * 获取列表
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return array 配置数组
     */
    public function lists($table, $where = [], $other = [])
    {
        try {
            $order = isset($other['order']) ? $other['order'] : null;
            $field = isset($other['field']) ? $other['field'] : '*';
            $page = isset($other['page']) ? $other['page'] : "1,1000"; //限制最多取1000数据
            $cache = isset($other['cache']) ? $other['cache'] : false;
            return \think\Db::name($table)
                            ->where($where)
                            ->order($order)
                            ->field($field)
                            ->page($page)
                            ->cache($cache)
                            ->select();
        } catch (Exception $ex) {
            //TO DO exception
            return [];
        }
    }
    
    /**
     * 获取列表，带统计
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return array 配置数组
     */
    public function lists_page($table, $where = [], $page=1, $limit=10, $other = [])
    {
        try {
            $total = $this->total($table, $where);
            $data = [];
            $totalPage = 0;
            if ($total > 0) {
                $totalPage = ceil($total / $limit);
                if ($page < 1) {
                    $page = 1;
                } else if ($page > $totalPage) {
                    $page = $totalPage;
                }
                ($limit < 1 || $limit > 99999) && $limit = 10;
                $other['page'] = $page.",".$limit;
                $data = $this->lists($table, $where, $other);
            }
            return ['total' => $total, 'total_page'=>$totalPage, 'current_page'=>$page, 'per_page'=>$limit, 'data' => $data];
        } catch (Exception $ex) {
            //TO DO exception
            return ['total' => 0, 'total_page'=>0, 'current_page' => 0, 'per_page'=>0, 'data' => []];
        }
    }

    /**
     * 获取单条数据
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return array 配置数组
     */
    public function one($table, $where = [], $other = [])
    {
        try {
            $field = isset($other['field']) ? $other['field'] : '*';
            $cache = isset($other['cache']) ? $other['cache'] : false;
            return \think\Db::name($table)
                            ->where($where)
                            ->field($field)
                            ->cache($cache)
                            ->find();
        } catch (Exception $ex) {
            //TO DO exception
            return [];
        }
    }
    
    /**
     * 执行SQL
     * 注意：此方法需要慎用，只能执行查询方法，并且只能临时简决一些复杂SQL，需要后期自行优化
     * @return array 配置数组
     */
    public function sql($sql = '', $bind = [], $fetch = false)
    {
        try {
            if (strtolower(substr($sql, 0, 6)) != "select") {
                return null;
            }
            return \think\Db::query($sql, $bind, $fetch);
        } catch (Exception $ex) {
            //TO DO exception
            return null;
        }
    }
    
    /**
     * 删除数据
     * @param type $table
     * @param type $where
     */
    public function delete($table, $where = [])
    {
        try {
            return \think\Db::name($table)->where($where)->delete();
        } catch (Exception $ex) {
            //TO DO exception
            return false;
        }
    }

    /**
     * 创建一条新数据
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return bool
     */
    public function create($table, $data = [], $mul = false)
    {
        try {
            if ($mul && isset($data[0])) {
                return \think\Db::name($table)->insertAll($data);
            } else {
                return \think\Db::name($table)->insert($data, false, true);
            }
        } catch (Exception $ex) {
            //TO DO exception
            return false;
        }
    }
    
    /**
     * 更新一条新数据
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return bool
     */
    public function update($table, $where = [], $data = [])
    {
        try {
            return \think\Db::name($table)->where($where)->update($data);
        } catch (Exception $ex) {
            //TO DO exception
            return false;
        }
    }
    
    /**
     * 统计数据
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return bool
     */
    public function total($table, $where = [], $field = '*')
    {
        try {
            return \think\Db::name($table)->where($where)->count($field);
        } catch (Exception $ex) {
            //TO DO exception
            return 0;
        }
    }
    
    /**
     * 取最大值
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return bool
     */
    public function max($table, $where = [], $field = '')
    {
        try {
            return \think\Db::name($table)->where($where)->max($field);
        } catch (Exception $ex) {
            //TO DO exception
            return false;
        }
    }
    
    /**
     * 取最大值
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return bool
     */
    public function min($table, $where = [], $field = '')
    {
        try {
            return \think\Db::name($table)->where($where)->min($field);
        } catch (Exception $ex) {
            //TO DO exception
            return false;
        }
    }
    
    /**
     * 取平均值
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return bool
     */
    public function avg($table, $where = [], $field = '')
    {
        try {
            return \think\Db::name($table)->where($where)->avg($field);
        } catch (Exception $ex) {
            //TO DO exception
            return false;
        }
    }
    
    /**
     * 求和
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return bool
     */
    public function sum($table, $where = [], $field = '')
    {
        try {
            return \think\Db::name($table)->where($where)->sum($field);
        } catch (Exception $ex) {
            //TO DO exception
            return false;
        }
    }
    
    /**
     * 自增
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return bool
     */
    public function inc($table, $where = [], $field = '', $num = 1)
    {
        try {
            return \think\Db::name($table)->where($where)->setInc($field, $num);
        } catch (Exception $ex) {
            //TO DO exception
            return false;
        }
    }
    
    /**
     * 自减
     * 注意：调用此方法只能是单一业务逻辑的功能，其它复杂业务，请单开接口实现
     * @return bool
     */
    public function dec($table, $where = [], $field = '', $num = 1)
    {
        try {
            return \think\Db::name($table)->where($where)->setDec($field, $num);
        } catch (Exception $ex) {
            //TO DO exception
            return false;
        }
    }

}
